/**
 * 设备检测服务
 * 
 * 用于识别和检测各种硬件设备类型
 * 支持多种设备识别方式和降级策略
 */

const deviceTypesRegistry = require('./device-types');
const { logger } = require('../utils/logger');

/**
 * 设备检测服务
 */
const deviceDetector = {
  /**
   * 通过设备标识符识别设备类型
   * @param {Object} deviceIdentifier - 设备标识信息
   * @returns {Object} 识别结果
   */
  identifyDeviceType: function(deviceIdentifier) {
    logger.info('开始识别设备类型', deviceIdentifier);
    
    // 保证deviceIdentifier是有效对象
    if (!deviceIdentifier) {
      logger.error('设备标识符无效');
      return this._createEmptyResult();
    }
    
    // 获取设备标识信息
    const ssid = deviceIdentifier.ssid || '';
    const model = deviceIdentifier.model || '';
    const serialNumber = deviceIdentifier.serialNumber || '';
    const bssid = deviceIdentifier.bssid || '';
    
    logger.info(`设备信息: SSID=${ssid}, Model=${model}, SerialNumber=${serialNumber}, BSSID=${bssid}`);
    
    // 获取所有已注册设备类型
    const deviceTypes = deviceTypesRegistry.getAllDeviceTypes();
    logger.info(`当前已注册 ${deviceTypes.length} 种设备类型`);
    
    // 用于存储识别结果
    let bestMatch = null;
    let highestConfidence = 0;
    
    // 尝试每个设备类型的识别方法
    for (const typeInfo of deviceTypes) {
      const deviceType = typeInfo.type;
      const deviceModule = deviceTypesRegistry.getDeviceType(deviceType);
      
      if (!deviceModule) {
        logger.warn(`无法获取设备类型 "${deviceType}" 的模块`);
        continue;
      }
      
      // 调用设备类型模块的标识方法
      if (deviceModule.identifyDevice) {
        try {
          const identifyResult = deviceModule.identifyDevice({
            ssid,
            model,
            serialNumber,
            bssid
          });
          
          if (identifyResult && identifyResult.match) {
            const confidence = identifyResult.confidence || 0.5;
            logger.info(`设备类型 "${deviceType}" 匹配成功，置信度: ${confidence}`);
            
            // 如果是更好的匹配，则更新最佳匹配
            if (confidence > highestConfidence) {
              highestConfidence = confidence;
              bestMatch = {
                deviceType: deviceType,
                confidence: confidence,
                deviceInfo: identifyResult.deviceInfo || {}
              };
            }
          } else {
            logger.info(`设备类型 "${deviceType}" 不匹配`);
          }
        } catch (error) {
          logger.error(`调用设备类型 "${deviceType}" 的识别方法时出错:`, error);
        }
      } else {
        logger.warn(`设备类型 "${deviceType}" 未实现 identifyDevice 方法`);
      }
    }
    
    // 如果找到匹配，返回最佳匹配结果
    if (bestMatch) {
      logger.info(`最佳匹配设备类型: "${bestMatch.deviceType}", 置信度: ${bestMatch.confidence}`);
      return bestMatch;
    }
    
    // 如果没有精确匹配，尝试基于规则的通用识别
    logger.info('未找到精确匹配，尝试通用识别规则');
    return this.genericDeviceIdentify(deviceIdentifier);
  },
  
  /**
   * 通用设备识别逻辑（基于命名规则）
   * @param {Object} deviceIdentifier - 设备标识信息
   * @returns {Object} 识别结果
   */
  genericDeviceIdentify: function(deviceIdentifier) {
    // 保证deviceIdentifier是有效对象
    if (!deviceIdentifier) {
      return this._createEmptyResult();
    }
    
    const ssid = deviceIdentifier.ssid || '';
    
    // 检查淡水设备
    if (ssid.startsWith('ds_') || ssid.startsWith('ds_a01_')) {
      logger.info('通用规则匹配到淡水设备');
      return {
        deviceType: 'freshwater_lamp',
        confidence: 0.8,
        deviceInfo: {
          series: 'A01',
          generation: '1'
        }
      };
    }
    
    // 检查海水设备
    if (ssid.startsWith('hs_') || ssid.startsWith('hs_a01_')) {
      logger.info('通用规则匹配到海水设备');
      return {
        deviceType: 'seawater_lamp',
        confidence: 0.8,
        deviceInfo: {
          series: 'A01',
          generation: '1'
        }
      };
    }
    
    // 检查植物生长灯
    if (ssid.startsWith('pl_') || ssid.includes('plant')) {
      logger.info('通用规则匹配到植物生长灯');
      return {
        deviceType: 'plant_growth_lamp',
        confidence: 0.7,
        deviceInfo: {
          series: 'PL',
          generation: '1'
        }
      };
    }
    
    // 未能识别的设备
    logger.warn('未能识别设备类型');
    return this._createEmptyResult();
  },
  
  /**
   * 创建空的识别结果
   * @returns {Object} 空识别结果
   * @private
   */
  _createEmptyResult: function() {
    return {
      deviceType: null,
      confidence: 0,
      deviceInfo: {}
    };
  },
  
  /**
   * 获取设备类型的通道配置
   * @param {string} deviceType - 设备类型
   * @returns {Object} 通道配置
   */
  getDeviceChannelConfig: function(deviceType) {
    if (!deviceType) {
      return { channels: 4 };
    }
    
    const deviceModule = deviceTypesRegistry.getDeviceType(deviceType);
    if (!deviceModule) {
      return { channels: 4 };
    }
    
    try {
      const channelCount = deviceModule.getChannelCount();
      const settings = deviceModule.getDefaultSettings();
      
      return {
        channels: channelCount,
        channelNames: settings.channelNames || [],
        maxChannels: settings.maxChannels || channelCount
      };
    } catch (error) {
      logger.error(`获取设备 "${deviceType}" 的通道配置时出错:`, error);
      return { channels: 4 };
    }
  },
  
  /**
   * 检测设备是否在线
   * @param {Object} device - 设备对象
   * @returns {Promise<boolean>} 设备是否在线
   */
  checkDeviceOnline: async function(device) {
    if (!device || !device.id) {
      return false;
    }
    
    // 这里实现实际的设备在线检测逻辑
    // 示例实现，实际应根据设备类型进行不同的检测
    return new Promise((resolve) => {
      // 模拟一个异步检测过程
      setTimeout(() => {
        // 随机模拟设备在线状态，实际应用中应实现真实的检测
        const isOnline = Math.random() > 0.2;
        resolve(isOnline);
      }, 500);
    });
  }
};

module.exports = deviceDetector; 